export default function SrsRtcPlayerAsync () {
  var self = {}
  self.play = async function (url) {
    var conf = self.__internal.prepareUrl(url)
    self.pc.addTransceiver('audio', { direction: 'recvonly' })
    self.pc.addTransceiver('video', { direction: 'recvonly' })

    var offer = await self.pc.createOffer()
    await self.pc.setLocalDescription(offer)
    var session = await new Promise(function (resolve, reject) {
      var data = {
        api: conf.apiUrl,
        streamurl: conf.streamUrl,
        clientip: null,
        sdp: offer.sdp
      }
      function ajax (url, data) {
        var xhr = new XMLHttpRequest()
        xhr.open('POST', url)
        xhr.setRequestHeader('Content-Type', 'application/json')
        xhr.send(JSON.stringify(data))
        xhr.onload = function () {
          var res = xhr.responseText
          resolve(JSON.parse(res))
        }
        xhr.onerror = function () {
          // 调用失败回调函数并且将xhr对象传递给回调函数
          reject(xhr)
        }
      }

      ajax(conf.apiUrl, data)
    })
    await self.pc.setRemoteDescription(
      new RTCSessionDescription({
        type: 'answer',
        sdp: session.sdp
      })
    )
    return session
  }

  // Close the publisher.
  self.close = function () {
    self.pc.close()
  }

  // The callback when got remote stream.
  self.onaddstream = function (event) {
  }

  // Internal APIs.
  self.__internal = {
    defaultPath: '/rtc/v1/play/',
    prepareUrl: function (webrtcUrl) {
      var urlObject = self.__internal.parse(webrtcUrl)

      // If user specifies the schema, use it as API schema.
      var schema = urlObject.user_query.schema
      schema = schema ? schema + ':' : window.location.protocol

      var port = urlObject.port || 1985
      if (schema === 'https:') {
        port = urlObject.port || 443
      }
      var api = urlObject.user_query.play || self.__internal.defaultPath
      if (api.lastIndexOf('/') !== api.length - 1) {
        api += '/'
      }

      var apiUrl = schema + '//' + urlObject.server + ':' + port + api
      for (var key in urlObject.user_query) {
        if (key !== 'api' && key !== 'play') {
          apiUrl += '&' + key + '=' + urlObject.user_query[key]
        }
      }
      // Replace /rtc/v1/play/&k=v to /rtc/v1/play/?k=v
      apiUrl = apiUrl.replace(api + '&', api + '?')

      var streamUrl = urlObject.url

      return {
        apiUrl: apiUrl,
        streamUrl: streamUrl,
        schema: schema,
        urlObject: urlObject,
        port: port
      }
    },
    parse: function (url) {
      var a = document.createElement('a')
      a.href = url.replace('rtmp://', 'http://')
        .replace('webrtc://', 'http://')
        .replace('rtc://', 'http://')

      var vhost = a.hostname
      var app = a.pathname.substr(1, a.pathname.lastIndexOf('/') - 1)
      var stream = a.pathname.substr(a.pathname.lastIndexOf('/') + 1)

      // parse the vhost in the params of app, that srs supports.
      app = app.replace('...vhost...', '?vhost=')
      if (app.indexOf('?') >= 0) {
        var params = app.substr(app.indexOf('?'))
        app = app.substr(0, app.indexOf('?'))

        if (params.indexOf('vhost=') > 0) {
          vhost = params.substr(params.indexOf('vhost=') + 'vhost='.length)
          if (vhost.indexOf('&') > 0) {
            vhost = vhost.substr(0, vhost.indexOf('&'))
          }
        }
      }

      // when vhost equals to server, and server is ip,
      // the vhost is __defaultVhost__
      if (a.hostname === vhost) {
        var re = /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/
        if (re.test(a.hostname)) {
          vhost = '__defaultVhost__'
        }
      }

      // parse the schema
      var schema = 'rtmp'
      if (url.indexOf('://') > 0) {
        schema = url.substr(0, url.indexOf('://'))
      }

      var port = a.port
      if (!port) {
        if (schema === 'http') {
          port = 80
        } else if (schema === 'https') {
          port = 443
        } else if (schema === 'rtmp') {
          port = 1935
        }
      }

      var ret = {
        url: url,
        schema: schema,
        server: a.hostname,
        port: port,
        vhost: vhost,
        app: app,
        stream: stream
      }
      self.__internal.fill_query(a.search, ret)

      // For webrtc API, we use 443 if page is https, or schema specified it.
      if (!ret.port) {
        if (schema === 'webrtc' || schema === 'rtc') {
          if (ret.user_query.schema === 'https') {
            ret.port = 443
          } else if (window.location.href.indexOf('https://') === 0) {
            ret.port = 443
          } else {
            // For WebRTC, SRS use 1985 as default API port.
            ret.port = 1985
          }
        }
      }

      return ret
    },
    fill_query: function (queryString, obj) {
      // pure user query object.
      obj.user_query = {}

      if (queryString.length === 0) {
        return
      }

      // split again for angularjs.
      if (queryString.indexOf('?') >= 0) {
        queryString = queryString.split('?')[1]
      }

      var queries = queryString.split('&')
      for (var i = 0; i < queries.length; i++) {
        var elem = queries[i]

        var query = elem.split('=')
        obj[query[0]] = query[1]
        obj.user_query[query[0]] = query[1]
      }

      // alias domain for vhost.
      if (obj.domain) {
        obj.vhost = obj.domain
      }
    }
  }

  self.pc = new RTCPeerConnection(null)
  self.pc.onaddstream = function (event) {
    if (self.onaddstream) {
      self.onaddstream(event)
    }
  }

  return self
}
